package org.dxy.trigger.http;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dxy.api.dto.request.CreateParamDefinitionRequest;
import org.dxy.api.dto.request.UpdateParamDefinitionRequest;
import org.dxy.api.dto.response.R;
import org.dxy.infrastructure.persistent.po.ParamDefinitionPo;
import org.dxy.trigger.http.service.ParamDefinitionApplicationService;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @description: 参数定义控制器
 * @author: dxy
 * @createTime: 2025/1/21
 */
@Slf4j
@RestController
@RequestMapping("/api/param-definition")
@RequiredArgsConstructor
public class ParamDefinitionController {
    
    private final ParamDefinitionApplicationService paramDefinitionApplicationService;

    /**
     * 创建参数定义
     * @param dto 参数定义创建请求DTO
     * @return 操作结果
     */
    @PostMapping("/create")
    public R<Long> create(@Validated @RequestBody CreateParamDefinitionRequest dto) {
        log.info("创建参数定义请求 - 参数编码: {}, 参数名称: {}", dto.getCode(), dto.getName());
        
        try {
            R<Long> result = paramDefinitionApplicationService.create(dto);
            if (result.isOk()) {
                log.info("参数定义创建成功 - 参数编码: {}, ID: {}", dto.getCode(), result.getData());
            } else {
                log.warn("参数定义创建失败 - 参数编码: {}, 错误信息: {}", dto.getCode(), result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("参数定义创建异常 - 参数编码: {}", dto.getCode(), e);
            return R.fail("参数定义创建失败: " + e.getMessage());
        }
    }

    /**
     * 更新参数定义
     * @param dto 参数定义更新请求DTO
     * @return 操作结果
     */
    @PutMapping("/update")
    public R<Void> update(@Validated @RequestBody UpdateParamDefinitionRequest dto) {
        log.info("更新参数定义请求 - ID: {}, 参数编码: {}", dto.getId(), dto.getCode());
        
        try {
            R<Void> result = paramDefinitionApplicationService.update(dto);
            if (result.isOk()) {
                log.info("参数定义更新成功 - ID: {}", dto.getId());
            } else {
                log.warn("参数定义更新失败 - ID: {}, 错误信息: {}", dto.getId(), result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("参数定义更新异常 - ID: {}", dto.getId(), e);
            return R.fail("参数定义更新失败: " + e.getMessage());
        }
    }

    /**
     * 分页查询参数定义列表
     * @param page 分页参数
     * @param query 查询条件
     * @return 分页的参数定义列表
     */
    @GetMapping("/list")
    public R<Page<ParamDefinitionPo>> list(
            @ParameterObject Page<ParamDefinitionPo> page,
            @ParameterObject ParamDefinitionPo query) {
        log.info("分页查询参数定义列表 - 页码: {}, 每页大小: {}", page.getCurrent(), page.getSize());
        
        try {
            R<Page<ParamDefinitionPo>> result = paramDefinitionApplicationService.list(page, query);
            if (result.isOk()) {
                log.info("参数定义列表查询成功 - 总数: {}", result.getData().getTotal());
            }
            return result;
        } catch (Exception e) {
            log.error("参数定义列表查询异常", e);
            return R.fail("参数定义列表查询失败: " + e.getMessage());
        }
    }

    /**
     * 查询参数定义详情
     * @param id 参数定义ID
     * @return 参数定义详情
     */
    @GetMapping("/{id}")
    public R<ParamDefinitionPo> getById(@PathVariable Long id) {
        log.info("查询参数定义详情 - ID: {}", id);
        
        if (id == null || id <= 0) {
            log.warn("无效的参数定义ID: {}", id);
            return R.fail("参数定义ID不能为空且必须为正整数");
        }
        
        try {
            R<ParamDefinitionPo> result = paramDefinitionApplicationService.getById(id);
            if (result.isOk()) {
                log.info("参数定义详情查询成功 - ID: {}", id);
            } else {
                log.warn("参数定义详情查询失败 - ID: {}, 错误信息: {}", id, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("参数定义详情查询异常 - ID: {}", id, e);
            return R.fail("参数定义详情查询失败: " + e.getMessage());
        }
    }

    /**
     * 根据参数编码查询参数定义
     * @param code 参数编码
     * @return 参数定义详情
     */
    @GetMapping("/code/{code}")
    public R<ParamDefinitionPo> getByCode(@PathVariable String code) {
        log.info("根据参数编码查询参数定义 - 编码: {}", code);
        
        if (code == null || code.trim().isEmpty()) {
            log.warn("参数编码不能为空");
            return R.fail("参数编码不能为空");
        }
        
        try {
            R<ParamDefinitionPo> result = paramDefinitionApplicationService.getByCode(code);
            if (result.isOk()) {
                log.info("参数定义查询成功 - 编码: {}", code);
            } else {
                log.warn("参数定义查询失败 - 编码: {}, 错误信息: {}", code, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("参数定义查询异常 - 编码: {}", code, e);
            return R.fail("参数定义查询失败: " + e.getMessage());
        }
    }

    /**
     * 获取所有参数定义（用于下拉选择）
     * @return 参数定义列表
     */
    @GetMapping("/all")
    public R<List<ParamDefinitionPo>> getAll() {
        log.info("获取所有参数定义");
        
        try {
            R<List<ParamDefinitionPo>> result = paramDefinitionApplicationService.getAll();
            if (result.isOk()) {
                log.info("获取所有参数定义成功 - 数量: {}", result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("获取所有参数定义异常", e);
            return R.fail("获取所有参数定义失败: " + e.getMessage());
        }
    }

    /**
     * 根据输入类型查询参数定义
     * @param inputType 输入类型（AUTO_COLLECT/MANUAL_INPUT）
     * @return 参数定义列表
     */
    @GetMapping("/input-type/{inputType}")
    public R<List<ParamDefinitionPo>> getByInputType(@PathVariable String inputType) {
        log.info("根据输入类型查询参数定义 - 输入类型: {}", inputType);
        
        try {
            R<List<ParamDefinitionPo>> result = paramDefinitionApplicationService.getByInputType(inputType);
            if (result.isOk()) {
                log.info("根据输入类型查询参数定义成功 - 输入类型: {}, 数量: {}", inputType, result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("根据输入类型查询参数定义异常 - 输入类型: {}", inputType, e);
            return R.fail("根据输入类型查询参数定义失败: " + e.getMessage());
        }
    }

    /**
     * 删除参数定义
     * @param id 参数定义ID
     * @return 操作结果
     */
    @DeleteMapping("/{id}")
    public R<Void> delete(@PathVariable Long id) {
        log.info("删除参数定义请求 - ID: {}", id);
        
        if (id == null || id <= 0) {
            log.warn("无效的参数定义ID: {}", id);
            return R.fail("参数定义ID不能为空且必须为正整数");
        }
        
        try {
            R<Void> result = paramDefinitionApplicationService.delete(id);
            if (result.isOk()) {
                log.info("参数定义删除成功 - ID: {}", id);
            } else {
                log.warn("参数定义删除失败 - ID: {}, 错误信息: {}", id, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("参数定义删除异常 - ID: {}", id, e);
            return R.fail("参数定义删除失败: " + e.getMessage());
        }
    }

    /**
     * 批量删除参数定义
     * @param ids 参数定义ID列表
     * @return 操作结果
     */
    @DeleteMapping("/batch")
    public R<Void> batchDelete(@RequestBody List<Long> ids) {
        log.info("批量删除参数定义请求 - ID列表: {}", ids);
        
        if (ids == null || ids.isEmpty()) {
            log.warn("批量删除请求参数无效: ID列表为空");
            return R.fail("参数定义ID列表不能为空");
        }
        
        // 验证ID列表中的每个ID都是有效的正整数
        for (Long id : ids) {
            if (id == null || id <= 0) {
                log.warn("批量删除请求参数无效: 包含无效的参数定义ID {}", id);
                return R.fail("参数定义ID列表中包含无效的ID: " + id);
            }
        }
        
        if (ids.size() > 100) {
            log.warn("批量删除请求参数无效: 一次删除的参数定义数量过多 {}", ids.size());
            return R.fail("一次最多只能删除100个参数定义");
        }
        
        try {
            R<Void> result = paramDefinitionApplicationService.batchDelete(ids);
            if (result.isOk()) {
                log.info("批量删除参数定义成功 - 删除数量: {}", ids.size());
            } else {
                log.warn("批量删除参数定义失败 - ID列表: {}, 错误信息: {}", ids, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("批量删除参数定义异常 - ID列表: {}", ids, e);
            return R.fail("批量删除参数定义失败: " + e.getMessage());
        }
    }
}